cJoin: join with communicating transactions

This paper proposes a formal approach to the design and programming of Long Running Transactions (LRT). We exploit techniques from process calculi to define cJoin, which is an extension of the join calculus with few well-disciplined primitives for LRT. Transactions in cJoin are intended to describe the transactional interaction of several partners, under the assumption that any partner executing a transaction may communicate only with other transactional partners. In such case, the transactions run by any party are bound to achieve the same outcome (i.e., all succeed or all fail). Hence, a distinguishing feature of cJoin, called dynamic joinability, is that ongoing transactions can be merged to complete their tasks and when this happens either all succeed or all abort. Additionally, cJoin is based on compensations, i.e., partial executions of transactions are recovered by executing user-defined programs instead of providing automatic roll-back. The expressiveness and generality of cJoin is demonstrated by many examples addressing common programming patterns. The mathematical foundation is accompanied by a prototype language implementation, which is an extension of the jocaml compiler

Reconfigurable and software-defined networks of connectors and components

The diffusion of adaptive systems motivate the study of models of software entities whose interaction capabilities can evolve dynamically. In this paper we overview the contributions in the ASCENS project in the area of software defined networks and of reconfigurable connectors. In particular we highlight: (i) the definition of the Network-conscious pi-calculus and its use in the modeling and verification of the PASTRY protocol, and (ii) the mutual correspondence between different frameworks for defining networks of connectors together with two suitable enhancements for addressing dynamically changing systems

Constraint design rewriting

Constraint networks are hyper-graphs whose nodes and hyper-edges represent variables and relations between them, respectively. The problem to assign values to variables by satisfying all constraints is NP-complete. We propose an algebraic approach to the design and transformation of constraint networks, inspired by Architectural Design Rewriting (ADR). The main idea is to exploit ADR to equip constraint networks with some hierarchical structure and represent them as terms of a suitable algebra, when possible. Constraint network transformations such as constraint propagations are then specified with efficient rewrite rules exploiting the network's structure provided by terms. The approach can be understood as (i) an extension of ADR with constraints, and (ii) an application of ADR to the design of reconfigurable constraint networks

AN ALGEBRAIC SEMANTICS FOR STRUCTURED TRANSITION-SYSTEMS AND ITS APPLICATION TO LOGIC PROGRAMS

We present a general methodology aimed at providing an algebraic semantics for a large class of formalisms. The methodology, which generalizes the algebraic treatment of Petri nets proposed by Meseguer and Montanari (1990) individuates three levels of description of a formalism (i.e., programs, structured transition systems, and models), and defines two free constructions which generate in an automatic way the induced transition system and the free model of a program. These constructions are parametric with respect to the structure of states and transitions: instantiating them in various ways, different formalisms can be treated. The construction of the free model extends the algebraic structure of transitions to the computations of a program, thus producing a category having as arrows abstract computations, i.e., equivalence classes of concrete computations. Interestingly, the equivalence relation induced on computations captures some basic properties of true concurrency. Moreover, by general categorical properties the construction of the free model is compositional w.r.t. various forms of program union. As a running example, we apply the methodology to phrase structure grammars, while the main case study is logic programming. For both formalisms the free model is shown to include all the computations at a natural level of abstraction: the free model of a grammar includes all its derivation trees as arrows, while the arrows of the free model of a logic program are parallel refutations

Reactive systems, (semi-)saturated semantics and coalgebras on presheaves

The semantics of process calculi has traditionally been specified by labelled transition systems (LTSS), but, with the development of name calculi, it turned Out that reaction rules (i.e., Unlabelled transition rules) are often more natural. This leads to the question of how behavioral equivalences (bisimilarity, trace equivalence, etc.) defined for US can be transferred to unlabelled transition systems. Recently, in order to answer this question, several proposals have been made with the aim of automatically deriving an LTS from reaction rules in Such a way that the resulting equivalences are congruences. Furthermore, these equivalences should agree with the standard semantics, whenever one exists. In this paper, we propose saturated semantics, based on a weaker notion of observation and orthogonal to all the previous proposals, and we demonstrate the appropriateness of our semantics by means of two examples: logic programming and open Petri nets. We also show that saturated semantics can be efficiently characterized through the so called semi-saturated games. Finally, we provide coalgebraic models relying on presheaves. (C) 2009 Elsevier B.V. All rights reserved